const express = require('express');
const router = express.Router();
const db = require('./db');
const crypto = require('crypto');
const XLSX = require('xlsx');

// const sessionMiddleware = require('./sessionMiddleware'); // 替换为你自己的配置模块
// router.use(sessionMiddleware);



// 注册新用户
router.post('/register', (req, res) => {
  const { username, password, email } = req.body;

  // 执行SQL查询检查用户名是否存在
  const checkQuery = `SELECT * FROM tpadmin_user_user WHERE username = ?`;
  db.connection.query(checkQuery, [username], (checkError, checkResults) => {
    if (checkError) {
      console.error('注册失败:', checkError);
      res.status(500).json({ msg: '注册失败' });
    } else {
      if (checkResults.length > 0) {
        res.status(409).json({ msg: '用户名已存在' });
      } else {
        // 随机生成盐值
        const salt = crypto.randomBytes(16).toString('hex');

        // 使用MD5加盐处理密码
        const hashedPassword = crypto
          .createHash('md5')
          .update(password + salt)
          .digest('hex');

        // 执行SQL查询插入用户信息
        const insertQuery = `INSERT INTO tpadmin_user_user (username, password, salt, email,points) VALUES (?, ?, ?, ?,?)`;
        db.connection.query(insertQuery, [username, hashedPassword, salt, email, 0], (insertError, insertResults) => {
          if (insertError) {
            console.error('注册失败:', insertError);
            res.status(500).json({ msg: '注册失败' });
          } else {
            // 注册成功，可以发送确认邮件或直接通知用户
            res.status(201).json({ msg: '注册成功', data: { id: insertResults.insertId, username: username, points: 0 } });
          }
        });
      }
    }
  });
});
// 用户登录
router.post('/login', (req, res) => {
  const { username, password } = req.body;
  // 执行SQL查询获取用户信息
  const query = `SELECT * FROM tpadmin_user_user WHERE username = ?`;
  db.connection.query(query, [username], (error, results) => {
    if (error) {
      console.error('登录失败:', error);
      res.status(500).json({ msg: '登录失败' });
    } else {
      if (results.length === 0) {
        res.status(401).json({ msg: '用户名或密码错误' });
      } else {
        const user = results[0];
        // 使用用户记录中的盐值对输入的密码进行加密
        const hashedPassword = crypto
          .createHash('md5')
          .update(password + user.salt)
          .digest('hex');
        if (hashedPassword === user.password) {
          // 用户登录成功
          // 生成新的 session_id
          const sessionId = crypto.randomBytes(32).toString('hex');
          // 将 session_id 存储在会话中
          req.session.session_id = sessionId;
          req.session.userId = user.id;
          req.session.username = user.username;
          req.session.points = user.points;
          // console.log('%cbackend\\userApi.js:77 "登录成功"', 'color: #007acc;', "登录成功");
          // console.log('%cbackend\\userApi.js:78 object', 'color: #007acc;', req.session);
          res.status(200).json({ msg: '登录成功', data: { id: user.id, username: user.username, session_id: sessionId, points: user.points } });
        } else {

          res.status(401).json({ msg: '用户名或密码错误' });
        }
      }
    }
  });
});

// 获取当前用户信息
router.get('/', (req, res) => {
  const authHeader = req.headers['authorization'];
  if (authHeader) {
    // console.log('%cbackenduserApi.js:99 req.session', 'color: #007acc;', req.session)
    res.status(200).json({
      data: {
        username: req.session.username,
        id: req.session.userId,
        points: req.session.points
      },
      code: 1,
      msg: "",
      sessionId: authHeader
    });
  } else {
    res.status(200).json({
      code: 2,
      message: '用户未登录'
    },
    );
  }
});


// 用户登出
router.get('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      console.error('登出失败:', err);
      res.status(500).json({ message: '登出失败' });
    } else {
      console.log('用户已登出');
      res.status(200).json({ message: '用户已登出' });
      // 可以选择重定向到登录页面或其他默认页面
      // res.redirect('/login');
    }
  });
});

// 获取用户列表
router.get('/users', (req, res) => {
  // 执行 SQL 查询获取用户列表信息
  const query = `SELECT * FROM tpadmin_user_user`;
  db.connection.query(query, (error, results) => {
    if (error) {
      console.error('获取用户列表失败:', error);
      res.status(500).json({ msg: '获取用户列表失败' });
    } else {
      res.status(200).json({ msg: '获取用户列表成功', data: results });
    }
  });
});

// 修改用户积分
router.put('/user/:id/points', (req, res) => {
  const userId = req.params.id;
  const { points } = req.body;

  // 执行 SQL 查询更新用户积分
  const updateQuery = `UPDATE tpadmin_user_user SET points = ? WHERE id = ?`;
  db.connection.query(updateQuery, [points, userId], (error, results) => {
    if (error) {
      console.error('修改用户积分失败:', error);
      res.status(500).json({ msg: '修改用户积分失败' });
    } else {
      res.status(200).json({ msg: '修改用户积分成功' });
    }
  });
});

// 删除用户
router.delete('/user/:id', (req, res) => {
  const userId = req.params.id;

  // 执行 SQL 查询删除用户
  const deleteQuery = `DELETE FROM tpadmin_user_user WHERE id = ?`;
  db.connection.query(deleteQuery, [userId], (error, results) => {
    if (error) {
      console.error('删除用户失败:', error);
      res.status(500).json({ msg: '删除用户失败' });
    } else {
      res.status(200).json({ msg: '删除用户成功' });
    }
  });
});

// 修改用户密码
router.put('/:id/password', (req, res) => {
  const userId = req.params.id;
  const { oldPassword, newPassword } = req.body;

  // 执行 SQL 查询获取用户信息
  const query = `SELECT * FROM tpadmin_user_user WHERE id = ?`;
  db.connection.query(query, [userId], (error, results) => {
    if (error) {
      console.error('获取用户信息失败:', error);
      res.status(500).json({ msg: '获取用户信息失败' });
    } else {
      if (results.length === 0) {
        res.status(404).json({ msg: '用户不存在' });
      } else {
        const user = results[0];
        // 使用用户记录中的盐值对输入的旧密码进行加密，并与数据库中保存的密码比较
        const hashedOldPassword = crypto
          .createHash('md5')
          .update(oldPassword + user.salt)
          .digest('hex');
        if (hashedOldPassword !== user.password) {
          res.status(401).json({ msg: '旧密码错误' });
        } else {
          // 随机生成新的盐值
          const newSalt = crypto.randomBytes(16).toString('hex');

          // 使用MD5加盐处理新密码
          const hashedNewPassword = crypto
            .createHash('md5')
            .update(newPassword + newSalt)
            .digest('hex');

          // 执行SQL查询更新用户密码和盐值
          const updateQuery = `UPDATE tpadmin_user_user SET password = ?, salt = ? WHERE id = ?`;
          db.connection.query(updateQuery, [hashedNewPassword, newSalt, userId], (updateError, updateResults) => {
            if (updateError) {
              console.error('修改密码失败:', updateError);
              res.status(500).json({ msg: '修改密码失败' });
            } else {
              res.status(200).json({ msg: '修改密码成功' });
            }
          });
        }
      }
    }
  });
});

// 查询用户积分
router.get('/:id/points', (req, res) => {
  const userId = req.params.id;
  console.log('%cbackend/userApi.js:227 userId', 'color: #007acc;', userId);
  // 执行 SQL 查询获取指定用户的积分信息
  const query = `SELECT points FROM tpadmin_user_user WHERE id = ?`;
  db.connection.query(query, [userId], (error, results) => {
    if (error) {
      console.error('获取用户积分失败:', error);
      res.status(500).json({ msg: '获取用户积分失败' });
    } else {
      if (results.length === 0) {
        res.status(404).json({ msg: '用户不存在' });
      } else {
        res.status(200).json({ msg: '获取用户积分成功', data: { points: results[0].points } });
      }
    }
  });
});

//批量修改积分
router.post('/upload-excel', (req, res) => {
  const { contents } = req.body;

  try {
    const workbook = XLSX.read(contents, { type: 'binary' });
    const worksheet = workbook.Sheets[workbook.SheetNames[0]];
    const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
    // 用于存储不存在的用户名
    const nonExistentUsernames = [];

    // 创建一个数组来存储查询用户是否存在的 Promise
    const checkExistencePromises = jsonData.map((row) => {
      if (row.length>1) {
        const username = row[0];
        return new Promise((resolve) => {
          const selectQuery = `SELECT * FROM tpadmin_user_user WHERE username = ?`;
          db.connection.query(selectQuery, [username], (error, results) => {
            if (error) {
              console.error(`查询用户名 ${username} 失败:`, error);
              resolve(false); // 查询失败，默认为用户不存在
            } else if (results.length === 0) {
              console.log('不存在的用户名：', username);
              nonExistentUsernames.push(username);
              resolve(false); // 用户不存在
            } else {
              resolve(true); // 用户存在
            }
          });
        });
      }
    });

    Promise.all(checkExistencePromises).then((existences) => {
      if (nonExistentUsernames.length > 0) {
        res.status(200).json({ msg: '以下用户名不存在，请先注册账号或删除表格错误行', usernames: nonExistentUsernames });
      } else {
        // 所有用户都存在，执行更新操作
        jsonData.forEach((row, index) => {
          const username = row[0];
          const pointsToAdd = row[1];

          if (existences[index]) {
            // 执行 SQL 更新语句
            const updateQuery = `UPDATE tpadmin_user_user SET points = points + ? WHERE username = ?`;
            db.connection.query(updateQuery, [pointsToAdd, username], (error, results) => {
              if (error) {
                console.error(`用户 ${username} 增加积分失败:`, error);
              } else {
                console.log(`用户 ${username} 增加积分成功`, pointsToAdd);
              }
            });
          }
        });

        res.status(200).json({ msg: '积分添加成功' });
      }
    });
  } catch (error) {
    console.error('处理上传的 Excel 文件失败:', error);
    res.status(500).json({ msg: '处理上传的 Excel 文件失败' });
  }
});

// 批量注册用户（通过Excel文件）
router.post('/batch-register', (req, res) => {
  const { contents } = req.body;

  try {
    const workbook = XLSX.read(contents, { type: 'binary' });
    const worksheet = workbook.Sheets[workbook.SheetNames[0]];
    const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });

    const results = {
      success: [],
      failed: []
    };

    // 使用 Promise.all 处理所有用户注册
    Promise.all(jsonData.map(row => {
      if (row.length < 2) return Promise.resolve(); // 跳过无效行

      return new Promise((resolve) => {
        const username = row[0];
        const password = row[1];
        const points = row[2] || 0; // 第三列是可选的积分

        // 检查用户名是否存在
        db.connection.query(
          'SELECT * FROM tpadmin_user_user WHERE username = ?',
          [username],
          (checkError, checkResults) => {
            if (checkError) {
              results.failed.push({ username, error: '数据库查询错误' });
              resolve();
            } else if (checkResults.length > 0) {
              results.failed.push({ username, error: '用户名已存在' });
              resolve();
            } else {
              // 生成盐值和加密密码
              const salt = crypto.randomBytes(16).toString('hex');
              const hashedPassword = crypto
                .createHash('md5')
                .update(password + salt)
                .digest('hex');

              // 插入新用户
              db.connection.query(
                'INSERT INTO tpadmin_user_user (username, password, salt, email, points) VALUES (?, ?, ?, ?, ?)',
                [username, hashedPassword, salt, '', points],
                (insertError) => {
                  if (insertError) {
                    results.failed.push({ username, error: '用户创建失败' });
                  } else {
                    results.success.push(username);
                  }
                  resolve();
                }
              );
            }
          }
        );
      });
    })).then(() => {
      res.status(200).json({
        msg: '批量注册处理完成',
        data: results
      });
    });
  } catch (error) {
    console.error('处理Excel文件失败:', error);
    res.status(500).json({ msg: '处理Excel文件失败' });
  }
});

module.exports = router;
